package com.beauty.order.service.impl;

import com.beauty.order.dto.OrderRequest;
import com.beauty.order.dto.OrderResponse;
import com.beauty.order.dto.PageResponse;
import com.beauty.order.entity.Order;
import com.beauty.order.entity.OrderItem;
import com.beauty.order.repository.OrderRepository;
import com.beauty.order.server.KafkaProducerService;
import com.beauty.order.service.OrderIntegrationService;
import com.beauty.order.service.OrderService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.persistence.EntityNotFoundException;
import jakarta.persistence.criteria.Predicate;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

/**
 * 订单服务实现类
 * 
 * 该类实现了OrderService接口，负责订单的创建、查询、更新等核心业务逻辑
 * 包括订单创建、状态管理、订单查询等功能
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class OrderServiceImpl implements OrderService {

    /**
     * Kafka生产者服务，用于发送订单相关消息
     */
    @Autowired
    KafkaProducerService kafkaProducerService;

    /**
     * 订单仓库，用于订单数据的持久化操作
     */
    private final OrderRepository orderRepository;
    
    /**
     * 订单集成服务，用于与其他微服务（如库存、物流）的交互
     */
    private final OrderIntegrationService orderIntegrationService;
    
    /**
     * JSON对象映射器，用于对象与JSON字符串的转换
     */
    private final ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 创建订单
     * 
     * @param orderRequest 订单请求对象，包含订单的所有信息
     * @return 创建成功的订单响应对象
     * @throws JsonProcessingException JSON处理异常
     */
    @Override
    @Transactional
    public OrderResponse createOrder(OrderRequest orderRequest) throws JsonProcessingException {
        log.info("【订单服务】开始创建订单，客户ID: {}", orderRequest.getCustomerId());

        // 检查和预留库存
        for (OrderRequest.OrderItemRequest itemRequest : orderRequest.getOrderItems()) {
            log.info("【订单服务】处理订单项: 产品ID={}, 名称={}, 数量={}",
                    itemRequest.getProductId(), itemRequest.getProductName(), itemRequest.getQuantity());

            // 检查库存
            log.info("【订单服务】开始检查产品[{}]库存", itemRequest.getProductId());
            if (!orderIntegrationService.checkProductInventory(itemRequest.getProductId(), itemRequest.getQuantity())) {
                log.error("【订单服务】产品[{}]库存不足", itemRequest.getProductId());
                throw new RuntimeException("产品 " + itemRequest.getProductId() + " 库存不足");
            }

            // 预留库存
            log.info("【订单服务】开始预留产品[{}]库存", itemRequest.getProductId());
            if (!orderIntegrationService.reserveInventory(itemRequest.getProductId(), itemRequest.getQuantity())) {
                log.error("【订单服务】预留产品[{}]库存失败", itemRequest.getProductId());
                throw new RuntimeException("预留产品 " + itemRequest.getProductId() + " 库存失败");
            }
        }

        log.info("【订单服务】所有产品库存检查和预留成功，开始创建订单记录");
        // 创建订单实体
        Order order = new Order();
        order.setOrderNumber(generateOrderNumber());
        order.setCustomerId(orderRequest.getCustomerId());
        order.setShippingCost(orderRequest.getShippingCost() != null ? orderRequest.getShippingCost() : BigDecimal.ZERO);
        order.setTaxAmount(orderRequest.getTaxAmount() != null ? orderRequest.getTaxAmount() : BigDecimal.ZERO);
        order.setPaymentMethod(orderRequest.getPaymentMethod());
        order.setShippingMethod(orderRequest.getShippingMethod());
        order.setShippingAddress(orderRequest.getShippingAddress());
        order.setBillingAddress(orderRequest.getBillingAddress());
        order.setNotes(orderRequest.getNotes());
        order.setStatus(Order.OrderStatus.PENDING);
        order.setOrderDate(LocalDateTime.now());

        // 处理订单项
        List<OrderItem> orderItems = new ArrayList<>();
        BigDecimal totalAmount = BigDecimal.ZERO;

        for (OrderRequest.OrderItemRequest itemRequest : orderRequest.getOrderItems()) {
            OrderItem orderItem = new OrderItem();
            orderItem.setProductId(itemRequest.getProductId());
            orderItem.setProductName(itemRequest.getProductName());
            orderItem.setProductImage(itemRequest.getProductImage());
            orderItem.setQuantity(itemRequest.getQuantity());
            orderItem.setUnitPrice(itemRequest.getUnitPrice());
            orderItem.setDiscountAmount(itemRequest.getDiscountAmount() != null ? itemRequest.getDiscountAmount() : BigDecimal.ZERO);

            // 计算订单项小计
            BigDecimal itemTotal = itemRequest.getUnitPrice().multiply(BigDecimal.valueOf(itemRequest.getQuantity()));
            if (itemRequest.getDiscountAmount() != null) {
                itemTotal = itemTotal.subtract(itemRequest.getDiscountAmount());
            }
            orderItem.setSubtotal(itemTotal);

            orderItem.setSku(itemRequest.getSku());

            // 处理options字段 - 将Map转换为JSON字符串
            if (itemRequest.getOptions() != null) {
                try {
                    String optionsJson = objectMapper.writeValueAsString(itemRequest.getOptions());
                    orderItem.setOptions(optionsJson);
                } catch (JsonProcessingException e) {
                    log.error("序列化options失败", e);
                    orderItem.setOptions(null);
                }
            }

            orderItems.add(orderItem);
            totalAmount = totalAmount.add(itemTotal);
        }

//        // 添加运费和税费到总金额
//        totalAmount = totalAmount.add(order.getShippingCost()).add(order.getTaxAmount());
//        order.setTotalAmount(totalAmount);
//        order.setOrderItems(orderItems);

        // 保存订单到数据库
        Order savedOrder = orderRepository.save(order);
        log.info("【订单服务】订单创建成功，订单号: {}, ID: {}", order.getOrderNumber(), order.getId());
        
        // 发送订单创建成功消息到Kafka
        String orderJson = objectMapper.writeValueAsString(order);
        kafkaProducerService.sendMessage("user-messages", "下单成功", orderJson);
        
        return OrderResponse.fromEntity(savedOrder);
    }

    /**
     * 根据ID获取订单
     * 
     * @param id 订单ID
     * @return 订单响应对象
     * @throws EntityNotFoundException 如果订单不存在
     */
    @Override
    public OrderResponse getOrderById(Long id) {
        Order order = orderRepository.findById(id)
                .orElseThrow(() -> new EntityNotFoundException("订单不存在，ID: " + id));
        return OrderResponse.fromEntity(order);
    }

    /**
     * 根据订单号获取订单
     * 
     * @param orderNumber 订单号
     * @return 订单响应对象
     * @throws EntityNotFoundException 如果订单不存在
     */
    @Override
    public OrderResponse getOrderByOrderNumber(String orderNumber) {
        Order order = orderRepository.findByOrderNumber(orderNumber)
                .orElseThrow(() -> new EntityNotFoundException("订单不存在，订单号: " + orderNumber));
        return OrderResponse.fromEntity(order);
    }

    /**
     * 根据客户ID获取该客户的所有订单
     * 
     * @param customerId 客户ID
     * @return 订单响应对象列表
     */
    @Override
    public List<OrderResponse> getOrdersByCustomerId(String customerId) {
        return orderRepository.findByCustomerId(customerId)
                .stream()
                .map(OrderResponse::fromEntity)
                .collect(Collectors.toList());
    }

    /**
     * 根据订单状态获取订单列表
     * 
     * @param status 订单状态
     * @return 订单响应对象列表
     */
    @Override
    public List<OrderResponse> getOrdersByStatus(Order.OrderStatus status) {
        return orderRepository.findByStatus(status)
                .stream()
                .map(OrderResponse::fromEntity)
                .collect(Collectors.toList());
    }
    /**
     * 根据日期范围获取订单列表
     *
     * 该方法通过调用orderRepository中的findByOrderDateBetween方法来查询指定日期范围内的订单
     * 查询结果转换为OrderResponse对象列表后返回
     *
     * @param start 开始时间，用于指定查询的起始日期和时间
     * @param end 结束时间，用于指定查询的结束日期和时间
     * @return 返回一个OrderResponse对象的列表，每个对象对应一个在指定日期范围内的订单
     */
    @Override
    public List<OrderResponse> getOrdersByDateRange(LocalDateTime start, LocalDateTime end) {
        return orderRepository.findByOrderDateBetween(start, end)
                .stream()
                .map(OrderResponse::fromEntity)
                .collect(Collectors.toList());
    }
    /**
     * 获取所有订单信息
     *
     * 本方法通过调用orderRepository的findAll方法来获取数据库中的所有订单信息，
     * 然后使用Stream API将每个订单实体对象映射到OrderResponse对象中，
     * 最后收集这些OrderResponse对象到一个列表中并返回
     *
     * @return 订单响应对象列表，包含所有订单信息
     */
    @Override
    public List<OrderResponse> getAllOrders() {
        return orderRepository.findAll()
                .stream()
                .map(OrderResponse::fromEntity)
                .collect(Collectors.toList());
    }
    /**
     * 更新订单状态
     *
     * @param id 订单ID
     * @param status 新的订单状态
     * @return 更新后的订单响应对象
     * @throws EntityNotFoundException 如果订单不存在
     */
    @Override
    @Transactional
    public OrderResponse updateOrderStatus(Long id, Order.OrderStatus status) {
        log.info("【订单服务】开始更新订单状态, ID: {}, 新状态: {}", id, status);
        Order order = orderRepository.findById(id)
                .orElseThrow(() -> new EntityNotFoundException("订单不存在，ID: " + id));

        log.info("【订单服务】订单当前状态: {}, 订单号: {}", order.getStatus(), order.getOrderNumber());
        order.setStatus(status);

        // 根据状态更新相应的日期
        switch (status) {
            case PAID:
                log.info("【订单服务】订单已支付，设置支付时间");
                order.setPaymentDate(LocalDateTime.now());
                break;
            case SHIPPED:
                log.info("【订单服务】订单发货处理开始");
                order.setShippingDate(LocalDateTime.now());

                // 减少库存（从预留状态转为实际消耗）
                log.info("【订单服务】开始处理订单中的{}个产品项的库存扣减", order.getOrderItems().size());
                for (OrderItem item : order.getOrderItems()) {
                    log.info("【订单服务】处理产品[{}]库存扣减，数量: {}", item.getProductId(), item.getQuantity());
                    if (!orderIntegrationService.reduceInventory(item.getProductId(), item.getQuantity())) {
                        log.error("【订单服务】减少产品[{}]库存失败", item.getProductId());
                        // 不抛出异常，防止影响订单状态更新
                    }
                }

                // 注意：物流单的创建应在前端选择承运商后通过专门的API调用创建
                // 这里不再自动创建物流单
                break;
            case DELIVERED:
                log.info("【订单服务】订单已送达，设置送达时间");
                order.setDeliveryDate(LocalDateTime.now());
                break;
            case CANCELLED:
                log.info("【订单服务】订单取消处理开始");
                // 如果订单取消，释放预留的库存
                log.info("【订单服务】开始处理订单中的{}个产品项的库存释放", order.getOrderItems().size());
                for (OrderItem item : order.getOrderItems()) {
                    log.info("【订单服务】处理产品[{}]预留库存释放，数量: {}", item.getProductId(), item.getQuantity());
                    if (!orderIntegrationService.releaseInventory(item.getProductId(), item.getQuantity())) {
                        log.error("【订单服务】释放产品[{}]预留库存失败", item.getProductId());
                        // 不抛出异常，防止影响订单状态更新
                    }
                }
                break;
            default:
                log.info("【订单服务】订单状态更新为: {}", status);
                break;
        }

        Order updatedOrder = orderRepository.save(order);
        log.info("【订单服务】订单状态更新成功，ID: {}, 订单号: {}, 新状态: {}",
                updatedOrder.getId(), updatedOrder.getOrderNumber(), updatedOrder.getStatus());
        return OrderResponse.fromEntity(updatedOrder);
    }

    /**
     * 更新订单的物流跟踪号
     *
     * 此方法用于根据订单ID更新订单的物流跟踪号，并返回更新后的订单信息
     * 如果订单不存在，则抛出EntityNotFoundException异常
     *
     * @param id 订单的唯一标识符
     * @param trackingNumber 物流跟踪号
     * @return 更新后的订单响应对象
     * @throws EntityNotFoundException 如果订单不存在
     */
    @Override
    @Transactional
    public OrderResponse updateTrackingNumber(Long id, String trackingNumber) {
        // 通过ID查找订单，如果不存在则抛出异常
        Order order = orderRepository.findById(id)
                .orElseThrow(() -> new EntityNotFoundException("订单不存在，ID: " + id));

        // 设置订单的物流跟踪号
        order.setTrackingNumber(trackingNumber);

        // 保存更新后的订单到数据库
        Order updatedOrder = orderRepository.save(order);

        // 将更新后的订单实体转换为响应对象并返回
        return OrderResponse.fromEntity(updatedOrder);
    }

    /**
     * 删除指定ID的订单
     *
     * 此方法首先检查订单数据库中是否存在给定ID的订单如果订单不存在，将抛出EntityNotFoundException异常
     * 如果订单存在，将删除该订单此方法使用了@Transactional注解，确保操作的原子性，避免数据不一致的问题
     *
     * @param id 订单的唯一标识符如果提供的ID不存在于数据库中，将抛出异常
     * @throws EntityNotFoundException 如果指定ID的订单在数据库中不存在
     */
    @Override
    @Transactional
    public void deleteOrder(Long id) {
        // 检查数据库中是否存在指定ID的订单
        if (!orderRepository.existsById(id)) {
            // 如果订单不存在，抛出异常
            throw new EntityNotFoundException("订单不存在，ID: " + id);
        }
        // 删除指定ID的订单
        orderRepository.deleteById(id);
    }

    /**
     * 获取订单列表的分页数据
     *
     * 此方法用于根据分页信息获取订单数据它首先记录了获取订单数据的日志，
     * 包括页码和每页大小，然后通过orderRepository查找所有订单实体，
     * 并将它们映射到OrderResponse对象中，最后将分页响应封装到PageResponse中返回
     *
     * @param pageable 分页信息，包含当前页码和每页大小
     * @return 返回包含订单数据的PageResponse对象
     */
    @Override
    public PageResponse<OrderResponse> getOrdersPage(Pageable pageable) {
        // 记录获取订单分页数据的日志
        log.info("【订单服务】获取订单分页数据，页码: {}, 每页大小: {}", pageable.getPageNumber(), pageable.getPageSize());
        // 查询所有订单实体并分页
        Page<Order> page = orderRepository.findAll(pageable);
        // 将订单实体映射到OrderResponse对象
        Page<OrderResponse> responsePage = page.map(OrderResponse::fromEntity);
        // 将分页响应封装到PageResponse中并返回
        return PageResponse.fromPage(responsePage);
    }

    /**
     * 根据客户ID获取订单分页信息
     *
     * 此方法通过客户的唯一标识符（customerId）来检索该客户的订单信息，并以分页的形式返回
     * 使用Spring Data的Pageable接口进行分页处理，以适应大量数据查询的需求
     *
     * @param customerId 客户的唯一标识符，用于查询特定客户的订单信息
     * @param pageable 分页信息，包括当前页码和每页大小
     * @return 返回一个包含订单信息的分页响应对象
     */
    @Override
    public PageResponse<OrderResponse> getOrdersByCustomerIdPage(String customerId, Pageable pageable) {
        // 记录获取客户订单分页数据的日志信息
        log.info("【订单服务】获取客户[{}]订单分页数据，页码: {}, 每页大小: {}",
                customerId, pageable.getPageNumber(), pageable.getPageSize());

        // 通过客户ID和分页信息查询订单数据
        Page<Order> page = orderRepository.findByCustomerId(customerId, pageable);

        // 将查询到的订单数据转换为响应对象
        Page<OrderResponse> responsePage = page.map(OrderResponse::fromEntity);

        // 将分页响应对象封装到自定义的PageResponse中并返回
        return PageResponse.fromPage(responsePage);
    }

    /**
     * 根据订单状态获取分页订单信息
     *
     * @param status 订单的状态，用于筛选订单
     * @param pageable 分页信息，包括当前页码和每页大小
     * @return 返回一个包含订单响应的分页响应对象
     *
     * 此方法主要用于处理根据订单状态获取分页订单信息的请求它首先记录了请求的日志，
     * 然后通过订单仓库根据状态获取分页订单实体，最后将这些实体映射为响应对象并返回
     */
    @Override
    public PageResponse<OrderResponse> getOrdersByStatusPage(Order.OrderStatus status, Pageable pageable) {
        // 记录获取订单信息的日志
        log.info("【订单服务】获取状态为[{}]的订单分页数据，页码: {}, 每页大小: {}",
                status, pageable.getPageNumber(), pageable.getPageSize());

        // 通过订单仓库根据状态和分页信息获取订单实体
        Page<Order> page = orderRepository.findByStatus(status, pageable);

        // 将订单实体映射为订单响应对象
        Page<OrderResponse> responsePage = page.map(OrderResponse::fromEntity);

        // 将分页响应对象封装并返回
        return PageResponse.fromPage(responsePage);
    }

    /**
     * 根据日期范围获取订单分页信息
     *
     * 该方法用于查询指定日期范围内的订单，并将结果以分页形式返回
     * 主要解决了订单数据量大时，一次性加载导致的性能问题，通过分页查询提高了查询效率和性能
     *
     * @param start 开始日期时间，表示查询范围的起始时间
     * @param end 结束日期时间，表示查询范围的结束时间
     * @param pageable 分页信息，包含了当前页码和每页大小等信息
     * @return 返回一个PageResponse对象，其中包含了分页查询结果和额外的分页元数据
     */
    @Override
    public PageResponse<OrderResponse> getOrdersByDateRangePage(LocalDateTime start, LocalDateTime end, Pageable pageable) {
        // 记录查询日期范围和分页信息的日志，用于监控和调试
        log.info("【订单服务】获取日期范围[{} - {}]内的订单分页数据，页码: {}, 每页大小: {}",
                start, end, pageable.getPageNumber(), pageable.getPageSize());

        // 通过订单日期范围和分页信息查询订单
        Page<Order> page = orderRepository.findByOrderDateBetween(start, end, pageable);

        // 将查询到的订单转换为OrderResponse对象，便于传输和使用
        Page<OrderResponse> responsePage = page.map(OrderResponse::fromEntity);

        // 将转换后的分页结果封装到PageResponse对象中返回
        return PageResponse.fromPage(responsePage);
    }

    /**
     * 根据关键字和分页信息搜索订单
     *
     * 此方法首先检查提供的关键字是否为空或仅包含空白字符如果关键字为空，
     * 则调用getOrdersPage方法获取不分关键字的订单列表如果关键字不为空，
     * 则使用orderRepository根据关键字进行模糊查询，并将结果转换为OrderResponse对象的分页
     *
     * @param keyword 搜索订单的关键字，用于模糊查询
     * @param pageable 分页信息，包括当前页码和页面大小
     * @return 返回一个包含订单信息的PageResponse对象
     */
    @Override
    public PageResponse<OrderResponse> searchOrders(String keyword, Pageable pageable) {
        // 记录查询日志
        log.info("【订单服务】执行关键字模糊查询: keyword={}", keyword);

        // 检查关键字是否为空
        if (keyword == null || keyword.trim().isEmpty()) {
            // 如果关键字为空，直接调用getOrdersPage方法获取订单分页
            return getOrdersPage(pageable);
        }

        // 使用关键字进行模糊查询
        Page<Order> page = orderRepository.searchByKeyword(keyword.trim(), pageable);

        // 将查询结果转换为OrderResponse对象的分页
        Page<OrderResponse> responsePage = page.map(OrderResponse::fromEntity);

        // 记录查询结果的日志
        log.info("【订单服务】模糊查询结果: 找到{}条记录", page.getTotalElements());

        // 将转换后的分页结果封装到PageResponse对象中并返回
        return PageResponse.fromPage(responsePage);
    }
    @Override
    @Transactional
    public Order updateOrderStatusByOrderNumber(String orderNumber, String status) {
        log.info("【订单服务】通过订单号更新订单状态: orderNumber={}, status={}", orderNumber, status);
        Order order = orderRepository.findByOrderNumber(orderNumber)
                .orElseThrow(() -> new EntityNotFoundException("订单不存在，订单号: " + orderNumber));

        order.setStatus(Order.OrderStatus.valueOf(status));

        // 如果状态为已支付，设置支付时间
        if ("PAID".equals(status)) {
            log.info("【订单服务】订单已支付，设置支付时间: {}", orderNumber);
            order.setPaymentDate(LocalDateTime.now());
        }

        return orderRepository.save(order);
    }
    /**
     * 高级搜索订单方法
     *
     * 该方法用于根据多个条件进行订单搜索每个搜索条件都是可选的，如果提供了搜索条件，
     * 则会对订单号、客户ID、追踪号、备注和送货地址进行模糊匹配搜索结果根据提供的分页信息进行分页
     *
     * @param orderNumber 订单号，用于模糊搜索如果为空，则不作为搜索条件
     * @param customerId 客户ID，用于模糊搜索如果为空，则不作为搜索条件
     * @param trackingNumber 追踪号，用于模糊搜索如果为空，则不作为搜索条件
     * @param notes 备注，用于模糊搜索如果为空，则不作为搜索条件
     * @param shippingAddress 送货地址，用于模糊搜索如果为空，则不作为搜索条件
     * @param pageable 分页信息，包括当前页和每页大小
     * @return 返回一个包含订单搜索结果的分页响应对象
     */
    @Override
    public PageResponse<OrderResponse> advancedSearch(String orderNumber, String customerId,
                                                    String trackingNumber, String notes,
                                                    String shippingAddress, Pageable pageable) {
        // 记录高级搜索的执行日志
        log.info("【订单服务】执行高级搜索: orderNumber={}, customerId={}, trackingNumber={}, notes={}, shippingAddress={}",
                orderNumber, customerId, trackingNumber, notes, shippingAddress);

        // 创建一个订单的动态查询条件
        Specification<Order> spec = (root, query, criteriaBuilder) -> {
            List<Predicate> predicates = new ArrayList<>();

            // 根据订单号进行模糊搜索
            if (StringUtils.hasText(orderNumber)) {
                predicates.add(criteriaBuilder.like(
                    criteriaBuilder.lower(root.get("orderNumber")),
                    "%" + orderNumber.toLowerCase() + "%"));
            }

            // 根据客户ID进行模糊搜索
            if (StringUtils.hasText(customerId)) {
                predicates.add(criteriaBuilder.like(
                    criteriaBuilder.lower(root.get("customerId")),
                    "%" + customerId.toLowerCase() + "%"));
            }

            // 根据追踪号进行模糊搜索
            if (StringUtils.hasText(trackingNumber)) {
                predicates.add(criteriaBuilder.like(
                    criteriaBuilder.lower(root.get("trackingNumber")),
                    "%" + trackingNumber.toLowerCase() + "%"));
            }

            // 根据备注进行模糊搜索
            if (StringUtils.hasText(notes)) {
                predicates.add(criteriaBuilder.like(
                    criteriaBuilder.lower(root.get("notes")),
                    "%" + notes.toLowerCase() + "%"));
            }

            // 根据送货地址进行模糊搜索
            if (StringUtils.hasText(shippingAddress)) {
                predicates.add(criteriaBuilder.like(
                    criteriaBuilder.lower(root.get("shippingAddress")),
                    "%" + shippingAddress.toLowerCase() + "%"));
            }

            // 将所有搜索条件组合为一个查询条件
            return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
        };

        // 使用动态查询条件和分页信息执行搜索
        Page<Order> page = orderRepository.findAll(spec, pageable);
        // 将搜索结果转换为响应对象
        Page<OrderResponse> responsePage = page.map(OrderResponse::fromEntity);
        // 记录搜索结果的日志
        log.info("【订单服务】高级搜索结果: 找到{}条记录", page.getTotalElements());
        // 返回搜索结果的分页响应
        return PageResponse.fromPage(responsePage);
    }

    /**
     * 生成订单编号
     *
     * 本方法通过拼接当前时间毫秒数和UUID的部分值来生成一个唯一的订单编号，
     * 以确保每个订单都有一个不重复的标识符，"ORD"前缀用于指示这是一个订单编号
     *
     * @return String 返回生成的唯一订单编号
     */
    private String generateOrderNumber() {
        return "ORD" + System.currentTimeMillis() + UUID.randomUUID().toString().substring(0, 4).toUpperCase();
    }

    /**
     * 根据订单ID获取订单实体
     * 此方法用于从数据库中查询特定ID对应的订单如果指定的ID在数据库中不存在，
     * 则返回null
     *
     * @param id 订单的唯一标识符
     * @return 返回找到的订单对象，如果不存在则返回null
     */
    @Override
    public Order getOrderByIdEntity(Long id) {
        return orderRepository.findById(id).orElse(null);
    }
}
